package cn.tedu.jsd2210.csmall.product.service.impl;

import cn.tedu.jsd2210.csmall.product.ex.ServiceException;
import cn.tedu.jsd2210.csmall.product.mapper.CategoryMapper;
import cn.tedu.jsd2210.csmall.product.pojo.dto.CategoryAddNewDto;
import cn.tedu.jsd2210.csmall.product.pojo.dto.CategoryUpdateDto;
import cn.tedu.jsd2210.csmall.product.pojo.entity.Album;
import cn.tedu.jsd2210.csmall.product.pojo.entity.Category;
import cn.tedu.jsd2210.csmall.product.pojo.vo.AlbumStandardVO;
import cn.tedu.jsd2210.csmall.product.pojo.vo.CategoryListItemVO;
import cn.tedu.jsd2210.csmall.product.pojo.vo.CategoryStandardVO;
import cn.tedu.jsd2210.csmall.product.service.ICategoryService;
import cn.tedu.jsd2210.csmall.product.web.ServiceCode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Slf4j
@Service

public class CategoryServiceImpl implements ICategoryService {
    @Autowired
    CategoryMapper categoryMapper;

    @Override
    public void addNew(CategoryAddNewDto categoryAddNewDto) {

        String name=categoryAddNewDto.getName();
        int count = categoryMapper.countByName(name);
        log.debug("根据名称[{}]统计数量,结果:{}",name,count);
        if(count>0){
            String message="添加类别失败,类别名称已被占用!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT,message);
        }
        //通过对象参数获取parentId
        Long parentId=categoryAddNewDto.getParentId();
        //预设深度值为1
        Integer depth=1;
        CategoryStandardVO parentCategory=null;
        Integer isParent;
        //判断parentId是否为0
        if(parentId!=0){
            //否 调用mapper的getStandardById()查询父级类别
            parentCategory= categoryMapper.getStandardById(parentId);
            //判断父级类别是否为null
            if(parentCategory==null){
                //是 抛出异常
                String message="添加失败!尝试查询的父级类别不存在!";
                log.debug(message);
                throw new ServiceException(ServiceCode.ERROR_NOT_FOUND,message);
            }
            //否 depth为父级深度+1;
            depth=parentCategory.getDepth()+1;
            isParent=1;
        }
        //创建实例对象
        Category category=new Category();
        //复制属性
        BeanUtils.copyProperties(categoryAddNewDto,category);
        //补全深度
        category.setDepth(depth);
        //补全是否父级属性
        category.setIsParent(0);
        //调用mapper插入数据
        int rows = categoryMapper.insert(category);
        if(rows!=1){
            String message="添加类别失败,服务器忙,请稍后再试!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_INSERT,message);
        }

//        new Category().getId().toString();//模拟异常,事务完整性试验

        //考虑是否将父级类别的isParent更新为1
        //判断parentId不为0且父级类别的isParent是否为0
        if(parentId!=0&&parentCategory.getIsParent()==0){
            Category updateParentCategory = new Category();
            updateParentCategory.setId(parentId);
            updateParentCategory.setIsParent(1);
            rows=categoryMapper.update(updateParentCategory);
            if(rows!=1){
                String message="添加类别失败,服务器忙,请稍后再试!";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERROR_INSERT,message);
            }
        }
    }
//TO完成DO 删除业务规则:当存在子级类别时(isParent为1),不允许删除.
//TO完成DO 删除业务规则:当所有子级类别被删除时,isParent更新为0.

    @Override
    public void deleteById(Long id) {
        log.debug("开始处理根据id删除类别的业务,参数:{}",id);
        //通过id查询数据是否为null
        CategoryStandardVO currentCategory = categoryMapper.getStandardById(id);
        if(currentCategory==null){
        //是 抛出异常
            String message="删除失败!尝试删除的类别不存在!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND,message);
        }
        //否 判断isParenId是否为1
        if(currentCategory.getIsParent()==1){
            //是 抛出异常
            String message="删除失败!尝试删除的类别存在子类别!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT,message);
        }
        //否 调用mapper删除数据
        int rows = categoryMapper.deleteById(id);
        if(rows!=1){
            String message="删除类别失败,服务器忙,请稍后再试!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_DELETE,message);
        }
        //调用mapper查询当前类别的parentId,统计数量,如数量为0,则更新其父级的isParent为0
        Long currentParentId = currentCategory.getParentId();
        int count = categoryMapper.countByParentId(currentParentId);
        if(count==0){
            Category parentCategory=new Category();
            parentCategory.setId(currentParentId);
            parentCategory.setIsParent(0);
            rows = categoryMapper.update(parentCategory);
            if(rows!=1){
                String message="删除类别失败,服务器忙,请稍后再试!";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERROR_UPDATE,message);
            }
        }
    }

    @Override
    public void setEnable(Long id) {
        updateEnableById(id,1);
    }

    @Override
    public void setDisable(Long id) {
        updateEnableById(id,0);
    }

    @Override
    public void setDisplay(Long id) {
        updateDisplayById(id,1);
    }

    @Override
    public void setUnDisplay(Long id) {
        updateDisplayById(id,0);
    }

    @Override
    public void updateInfoById(CategoryUpdateDto categoryUpdateDto, Long id) {
        log.debug("开始处理根据id{}修改类别的业务,新数据:{}",id,categoryUpdateDto);
        CategoryStandardVO  queryResult= categoryMapper.getStandardById(id);
        if(queryResult==null){
            String message="修改类别失败,尝试修改的类别数据不存在!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND,message);
        }
        int count = categoryMapper.countByNameAndNotId( categoryUpdateDto.getName(),id);
        if(count>0){
            String message="修改类别失败,类别名称已被占用!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT,message);
        }
        Category category=new Category();
        BeanUtils.copyProperties(categoryUpdateDto,category);
        category.setId(id);
        int rows = categoryMapper.update(category);
        if(rows!=1){
            String message="修改类别失败,服务器忙,请稍后再试!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_UPDATE,message);
        }
    }

    @Override
    public CategoryStandardVO getStandardById(Long id) {
        log.debug("开始处理[根据ID:{}查询类别详情]的业务",id);
        CategoryStandardVO queryResult = categoryMapper.getStandardById(id);
        if(queryResult==null){
            String message="查询类别详情失败,尝试查询的类别数据不存在!";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND,message);
        }
        return queryResult;
    }

    @Override
    public List<CategoryListItemVO> listByParentId(Long parentId) {
        log.debug("开始处理[查询类别列表]的业务,无参数");
        List<CategoryListItemVO> list = categoryMapper.listByParentId(parentId);
        return list;
    }

    private void updateEnableById(Long id, Integer enable) {

        //调用mapper对象的getStandardById方法查询
        CategoryStandardVO currentCategory = categoryMapper.getStandardById(id);
        //判断结果是否为null,是则抛出异常
        if(currentCategory==null){
            String message="修改类别失败,尝试修改的类别数据不存在!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND,message);
        }
        //判断查询结果中的enable与参数enable是否相同,是则抛出异常(当前状态与目标状态相同,没必要修改)
        Integer currentEnable = currentCategory.getEnable();
        if(currentEnable==enable){
            String message=ENABLE_TEXT[enable]+"失败,此类别已经处于该状态!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT,message);
        }
        //创建category对象
        Category updateCategory=new Category();
        //向对象封装属性
        updateCategory.setId(id);
        updateCategory.setEnable(enable);
        //调用mapper方法进行更新
        int rows = categoryMapper.update(updateCategory);
        if(rows!=1){
            String message="修改类别失败,服务器忙,请稍后再试!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_UPDATE,message);
        }
    }

    private void updateDisplayById(Long id, Integer isDisplay) {
        //调用mapper对象的getStandardById方法查询
        CategoryStandardVO currentCategory = categoryMapper.getStandardById(id);
        //判断结果是否为null,是则抛出异常
        if(currentCategory==null){
            String message="修改类别失败,尝试修改的类别数据不存在!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND,message);
        }
        //判断查询结果中的isDisplay与参数isDisplay是否相同,是则抛出异常(当前状态与目标状态相同,没必要修改)
        Integer currentIsDisplay = currentCategory.getIsDisplay();
        if(currentIsDisplay==isDisplay){
            String message=DISPLAY_TEXT[isDisplay]+"失败,此类别已经处于该状态!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT,message);
        }
        //创建category对象
        Category updateCategory=new Category();
        //向对象封装属性
        updateCategory.setId(id);
        updateCategory.setIsDisplay(isDisplay);
        //调用mapper方法进行更新
        int rows = categoryMapper.update(updateCategory);
        if(rows!=1){
            String message="修改类别失败,服务器忙,请稍后再试!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_UPDATE,message);
        }
    }
}
